const parser = require('@babel/parser');
const traverse = require('@babel/traverse').default;
const t = require('@babel/types');
const generator = require('@babel/generator').default;

// 辅助函数：尝试评估并替换表达式
function evaluateExpression(path) {
    try {
        // 获取表达式的字符串表示
        const code = generator(path.node).code;

        // 使用 Function 构造函数来评估表达式的值
        const value = new Function('return ' + code)();

        // 根据表达式的类型生成新的节点
        if (typeof value === 'boolean') {
            path.replaceWith(t.booleanLiteral(value));
        } else if (typeof value === 'number') {
            path.replaceWith(t.numericLiteral(value));
        } else if (typeof value === 'string') {
            path.replaceWith(t.stringLiteral(value));
        }
    } catch (err) {
        console.warn(`Could not evaluate expression: ${generator(path.node).code}`);
    }
}
// 处理 ConditionalExpression 类型的节点
function handleConditionalExpression(path) {
    try {
        // 获取条件表达式的字符串表示
        const conditionCode = generator(path.node.test).code;

        // 尝试评估条件表达式的值
        const conditionValue = new Function('return ' + conditionCode)();

        // 如果条件表达式可以静态求值，则选择相应的分支
        if (typeof conditionValue === 'boolean') {
            const resultPath = conditionValue ? path.node.consequent : path.node.alternate;
            path.replaceWith(resultPath);
        }
    } catch (err) {
        console.warn(`Could not evaluate conditional expression: ${generator(path.node).code}`);
    }
}
// 测试代码
// const a = !![];
// const b = "abc" == "bcd";
// const d = parseInt("5" + "0");
// const c = (1 << 3) | 2;
// const e = true ? "yes" : "no";
const code = `
    const e = true ? "yes" : "no";
`;

// 解析源代码为 AST
const ast = parser.parse(code, {
    sourceType: 'module'
});

// 定义 visitor 来遍历 AST 并简化表达式
const visitor = {
    UnaryExpression(path) {
        if (path.node.operator === '!' && path.node.prefix) {
            evaluateExpression(path);
        }
    },
    BinaryExpression(path) {
        if (['==', '!=', '===', '!==', '|', '<<'].includes(path.node.operator)) {
            evaluateExpression(path);
        }
    },
    CallExpression(path) {
        if (t.isIdentifier(path.node.callee, { name: 'parseInt' })) {
            evaluateExpression(path);
        }
    },
    ConditionalExpression(path) {
        handleConditionalExpression(path);
    }
};

// 使用定义的 visitor 遍历 AST
traverse(ast, visitor);

// 将修改后的 AST 转换回代码字符串
const output = generator(ast).code;
console.log(output);